FEXPTopologieKDTree.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// KD-tree data structure for mapping of 3D topology (FE nodes).
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPTOPOLOGIEKDTREE_H_
#define _CFEXPTOPOLOGIEKDTREE_H_
#include "FEXPCommon.h"
#include "FEXPDataContainer.h"
#include "FEXPGeom.h"


template<typename TValue>
class CFEXPKDHyperNode
{
public:
  CFEXPKDHyperNode(size_t dimension);
  CFEXPKDHyperNode(Ptr<TValue> & coordinates);
  virtual ~CFEXPKDHyperNode() { }
  // member data
  Ptr<TValue> _coordinates;
  // member functions
  TValue GetDistance(const CFEXPKDHyperNode & nd1, const CFEXPKDHyperNode & nd2);
  bool   operator== (const CFEXPKDHyperNode & to_compare);
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TValue>
CFEXPKDHyperNode<TValue>::CFEXPKDHyperNode(size_t dimension)
//--------------------------------------------------------------------------------------
{
#if !COORD_OPTIMIZATION_IS_ON
  _coordinates = CFEXPDataManager<TValue>::SafeAllocInstanceArray(dimension);
  size_t idx;
  FEXPCOMMON_FOREACH(FEXPCOMMON_DEFAULT_INDX, dimension - 1, idx)
    _coordinates.get()[idx] = 0;
#endif
}

//--------------------------------------------------------------------------------------
template<typename TValue>
CFEXPKDHyperNode<TValue>::CFEXPKDHyperNode(Ptr<TValue> & coordinates)
//--------------------------------------------------------------------------------------
{
#if !COORD_OPTIMIZATION_IS_ON
  auto length = coordinates.GetArrLength();
  if (!_coordinates)
    _coordinates = CFEXPDataManager<TValue>::SafeAllocInstanceArray(length);
  size_t idx;
  FEXPCOMMON_FOREACH(FEXPCOMMON_DEFAULT_INDX, length - 1, idx)
    _coordinates.get()[idx] = coordinates.get()[idx];
#else
  _coordinates = coordinates;
#endif
}

//--------------------------------------------------------------------------------------
template<typename TValue>
TValue CFEXPKDHyperNode<TValue>::GetDistance(const CFEXPKDHyperNode & nd1, const CFEXPKDHyperNode & nd2)
//--------------------------------------------------------------------------------------
{
  size_t length1 = nd1._coordinates.GetArrLength();
  size_t length2 = nd2._coordinates.GetArrLength();
  if (length1 != length2)
    FEXPCOMMON_EXCEPTION("Error: KD-tree: Wrong coordinate dimension!!!");

  size_t start = FEXPCOMMON_DEFAULT_INDX, end = length1 - 1;
  size_t idx; TValue dist = 0;
  FEXPCOMMON_FOREACH(start, end, idx)
    dist += pow(nd2._coordinates.get()[idx] - nd1._coordinates.get()[idx], 2);
  return sqrt(dist);
}

//--------------------------------------------------------------------------------------
template<typename TValue>
bool CFEXPKDHyperNode<TValue>::operator==(const CFEXPKDHyperNode & to_compare)
//--------------------------------------------------------------------------------------
{
  size_t length1 = _coordinates.GetArrLength();
  size_t length2 = to_compare._coordinates.GetArrLength();
  if (length1 != length2)
    FEXPCOMMON_EXCEPTION("Error: KD-tree: Wrong coordinate dimension!!!");

  // compare values
  size_t start = FEXPCOMMON_DEFAULT_INDX, end = length1 - 1;
  size_t idx;
  FEXPCOMMON_FOREACH(start, end, idx)
  {
    if (CFEXPBaseConvers::Compare<TValue>(
      _coordinates.get()[idx], to_compare._coordinates.get()[idx]) == FEXPCOMMON_COMPARE_EQ)
      continue;
    return false;
  }
  return true;
}

// primary template
template<typename TData, typename TValue, typename Enable = void>
class CFEXPKDTreeNode { };
template<typename TValue, typename TData>
class CFEXPKDTreeNode
  // specialization
  <TData, TValue, typename std::enable_if<std::is_base_of<ICFEXPFECoordinatesBase<TValue>, TData>::value>::type>
{
public:
  CFEXPKDTreeNode(CFEXPKDHyperNode<TValue> * hyp_node, Ptr<TData> & data)
    : _data(data), _hpnd(hyp_node), _left(nullptr), _rght(nullptr) { }
  virtual ~CFEXPKDTreeNode() { }

  // member data
  Ptr<TData>                    _data;
  CFEXPKDHyperNode<TValue>*     _hpnd;
  CFEXPKDTreeNode*              _left;
  CFEXPKDTreeNode*              _rght;
  std::vector<CFEXPKDTreeNode*> _same_nodes_data;

  // member function for inserting node to KD-tree
  static CFEXPKDTreeNode * InsertNode(CFEXPKDHyperNode<TValue> * hyp_nd,
    CFEXPKDTreeNode * node, Ptr<TData> & data, size_t level, size_t dim,
    std::vector<Ptr<CFEXPKDTreeNode<TData, TValue>>> & collect_tree_nodes)
  {
    auto result = node;
    if (!result)
    {
      auto new_tree_node = CFEXPDataManager<CFEXPKDTreeNode>::SafeAllocInstance(hyp_nd, data);
      collect_tree_nodes.push_back(new_tree_node);
      result = new_tree_node.get();
    }
    else if ((*hyp_nd) == (*node->_hpnd))
    {
      // add the same data as node to vector
      auto new_tree_node = CFEXPDataManager<CFEXPKDTreeNode>::SafeAllocInstance(hyp_nd, data);
      collect_tree_nodes.push_back(new_tree_node);
      result->_same_nodes_data.push_back(new_tree_node.get());
      return result;
    }
    else if (hyp_nd->_coordinates.get()[level] > node->_hpnd->_coordinates.get()[level])
      result->_rght = InsertNode(hyp_nd, result->_rght, data, (level + 1) % dim, dim, collect_tree_nodes);
    else
      result->_left = InsertNode(hyp_nd, result->_left, data, (level + 1) % dim, dim, collect_tree_nodes);
    return result;
  }

  // member function for searching nodes which fitt bounding box
  static void SearchRange(CFEXPKDHyperNode<TValue> * lower, CFEXPKDHyperNode<TValue> * upper,
    CFEXPKDTreeNode * node, size_t level, size_t dim, Ptr<std::vector<Ptr<TData>>> & result)
  {
    if (!node)
      return;

    if (lower->_coordinates.get()[level] <= node->_hpnd->_coordinates.get()[level])
      SearchRange(lower, upper, node->_left, (level + 1) % dim, dim, result);

    size_t idx;
    FEXPCOMMON_FOREACH(FEXPCOMMON_DEFAULT_INDX, SIZE_MAX, idx)
    {
      auto to_continue = (idx < dim) &&
        (lower->_coordinates.get()[idx] <= node->_hpnd->_coordinates.get()[idx]) &&
        (upper->_coordinates.get()[idx] >= node->_hpnd->_coordinates.get()[idx]);
      if (to_continue)
        continue;
      break;
    }

    if (idx == dim)
    {
      // add node from tree
      result->push_back(node->_data);
      // add nodes with the same coordinates belong to tree node
      FEXPCOMMON_FOREACH_ITER_FNC(node->_same_nodes_data, { result->push_back(IT->_data); });
    }

    if (upper->_coordinates.get()[level] > node->_hpnd->_coordinates.get()[level])
      SearchRange(lower, upper, node->_rght, (level + 1) % dim, dim, result);
  }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


template<typename TData, typename TValue>
class CFEXPTopologieKDTree
{
public:
  CFEXPTopologieKDTree(size_t dimension);
  virtual ~CFEXPTopologieKDTree() { }

  void CreateTopologyTree(Ptr<ICFEXPDataModelContIntf> container, size_t opt_id);
  static Ptr<CFEXPTopologieKDTree<TData, TValue>>
    CreateTopologyTreeProgress(Ptr<ICFEXPDataModelContIntf> container, size_t dimension, size_t opt_id, std::string text);

  // member function for searching nodes which fitt bounding box
  Ptr<std::vector<Ptr<TData>>>
    GetNodesFromBoundingBox(const std::vector<TValue> & min_bound, const std::vector<TValue> & max_bound);
  // insert new data to tree
  void InsertData(Ptr<TData>              & data);
  void InsertData(std::vector<Ptr<TData>> & data);
protected:
  // [no protected members] -----------------------------
private:
  size_t                          _tree_dimension;
  size_t                          _tree_node_count;
  CFEXPKDTreeNode<TData, TValue>* _root;

  // KD-tree nodes (store here to deallocate)
  std::vector<Ptr<CFEXPKDTreeNode<TData, TValue>>> _kd_tree_nodes;
  // KD-tree hyper nodes (store here to deallocate)
  std::vector<Ptr<CFEXPKDHyperNode<TValue>>>       _kd_tree_hyper_nodes;
};

// kd tree default data structure typedef
template<typename TData>
using t_KD_def_tree = CFEXPTopologieKDTree<TData, t_fexpcommon_ct>;

// member functions
//--------------------------------------------------------------------------------------
template<typename TData, typename TValue>
CFEXPTopologieKDTree<TData, TValue>::CFEXPTopologieKDTree(size_t dimension)
  : _tree_dimension(dimension), _tree_node_count(FEXPCOMMON_DEFAULT_VALUE), _root(nullptr) { }
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<typename TData, typename TValue>
void CFEXPTopologieKDTree<TData, TValue>
  ::CreateTopologyTree(Ptr<ICFEXPDataModelContIntf> container, size_t opt_id)
//--------------------------------------------------------------------------------------
{
  container->IterateModElems([this](auto item)
    {
      InsertData(FEXPCOMMON_DYNCAST(ICFEXPModelDataIntf, TData, item));
      return true;
    }, opt_id);
}

//--------------------------------------------------------------------------------------
template<typename TData, typename TValue>
Ptr<CFEXPTopologieKDTree<TData, TValue>> CFEXPTopologieKDTree<TData, TValue>
  ::CreateTopologyTreeProgress(Ptr<ICFEXPDataModelContIntf> container, size_t dimension, size_t opt_id, std::string text)
//--------------------------------------------------------------------------------------
{
  Ptr<CFEXPTopologieKDTree> result;
  CFEXPAsyncRunner::RunProcedureWithProgress([&]
    {
      result = CFEXPDataManager<CFEXPTopologieKDTree>::SafeAllocInstance(dimension);
      result->CreateTopologyTree(container, opt_id);
    }, text);
  return result;
}

//--------------------------------------------------------------------------------------
template<typename TData, typename TValue>
void CFEXPTopologieKDTree<TData, TValue>::InsertData(Ptr<TData> & data)
//--------------------------------------------------------------------------------------
{
  if (!data)
    FEXPCOMMON_EXCEPTION("Error: KD-tree: Try add null data to tree!!!");
  auto array = data->GetCoordArray();

  if (array.GetArrLength() != _tree_dimension)
    FEXPCOMMON_EXCEPTION("Error: KD-tree: Try add data to tree with wrong coordinate dimension!!!");

  auto hyper_node = CFEXPDataManager<CFEXPKDHyperNode<TValue>>::SafeAllocInstance(array);
  _kd_tree_hyper_nodes.push_back(hyper_node);
  // insert node
  _root = CFEXPKDTreeNode<TData, TValue>::InsertNode(hyper_node.get(), _root,
    data, FEXPCOMMON_DEFAULT_VALUE, _tree_dimension, _kd_tree_nodes);
}

//--------------------------------------------------------------------------------------
template<typename TData, typename TValue>
void CFEXPTopologieKDTree<TData, TValue>::InsertData(std::vector<Ptr<TData>> & data)
//--------------------------------------------------------------------------------------
{
  FEXPCOMMON_FOREACH_ITER_FNC(data, { InsertData(IT); });
}

//--------------------------------------------------------------------------------------
template<typename TData, typename TValue>
Ptr<std::vector<Ptr<TData>>> CFEXPTopologieKDTree<TData, TValue>
  ::GetNodesFromBoundingBox(const std::vector<TValue> & min_bound, const std::vector<TValue> & max_bound)
//--------------------------------------------------------------------------------------
{
  size_t length1 = min_bound.size();
  size_t length2 = max_bound.size();
  if ((length1 != length2) || (length1 != _tree_dimension))
    FEXPCOMMON_EXCEPTION("Error: KD-tree: Wrong coordinate dimension!!!");

  auto minb = CFEXPDataManager<TValue>::SafeAllocInstanceArray(_tree_dimension);
  std::copy(min_bound.begin(), min_bound.end(), minb.get());
  auto mind = CFEXPDataManager<CFEXPKDHyperNode<TValue>>::SafeAllocInstance(minb);
  
  auto maxb = CFEXPDataManager<TValue>::SafeAllocInstanceArray(_tree_dimension);
  std::copy(max_bound.begin(), max_bound.end(), maxb.get());
  auto maxd = CFEXPDataManager<CFEXPKDHyperNode<TValue>>::SafeAllocInstance(maxb);
  
  // find nodes in bounding box range
  auto result = CFEXPDataManager<std::vector<Ptr<TData>>>::SafeAllocInstance();
  CFEXPKDTreeNode<TData, TValue>::SearchRange(mind.get(), maxd.get(), _root, FEXPCOMMON_DEFAULT_VALUE, _tree_dimension, result);
  return result;
}

#endif // !_CFEXPTOPOLOGIEKDTREE_H_